package com.hsp.Demo_11_innerclass;

public class Outter04 {
    public static void main(String[] args) {
        /*
        基于类（普通类和抽象类)的匿名内部类
         */
        AA04 aa04 = new AA04("jack"){
            @Override
            public void test() {
                super.test();
                System.out.println("基于类AA04创建的匿名内部类");
            }
        };

        aa04.test();
        System.out.println(aa04.getClass());
        /*new AA04(){}
        实际上底层是这样的：
            class Outter04$01 extends AA04{
                //重写了test()方法
            }
            基于类的匿名内部类，相当于是基于这个类，创建了子类，可以再{}中，编辑相应的逻辑代码。

        1、当不传参数的时候，调用的事AA04的无参构造器：
            1、AA04的无参构造器
            2、AA04的test()方法
            3、AA04创建的匿名内部类
         */

        /*new AA04("jack"){}
        2、当传参数的时候：
            猜想：是不是在AA04类中可以不含无参构造器？
              我觉的是的，确实注释掉无参构造方法后，没有报错
              class Outter$01 extends AA04{
                public Outter$01(){
                    //这里调用的是父类的有参构造器，所以即使没有无参构造器也不会报错。
                    super("jack");
                }
              }
              输出：
                1、AA04有参构造器
                2、test()方法
                3、匿名内部类

         */

        /*
        基于抽象类，创建匿名内部类是一样的道理，但是：
            1、基于类，是进行方法的重写。
            2、基于抽象类：可以是方法的重写，但是，还有一种抽象方法的 必须重写，这个匿名内部类，一定是一个
          类，而不是抽象类，所以抽象方法必须重写
         */

        BB04 bb04 = new BB04(){

            @Override
            void m1() {
                System.out.println("匿名内部类重写抽象类的方法");
            }
        };
        bb04.m1();
        System.out.println(bb04.getClass());
    }
}

class AA04{

    /*public AA04(){
        System.out.println("AA04的无参构造器");
    }*/

    public AA04(String str){
        System.out.println("AA04的带参数构造器的参数为：" + str);
    }

    //类中的方法
    public void test(){
        System.out.println("AA04的成员方法test()");
    }
}

abstract class BB04{

    abstract void m1();
}
